home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 301-325 / disk_315 / surf / revolve.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  6KB  |  316 lines
  1. #include <math.h>
  2. #include <stdio.h>
  3. #include "fasttrig.h"
  4. #include "bezpt.h"
  5. #include "revolve.h"
  6. #include "mytypes.h"
  7.  
  8.  
  9. RevAxisType RevAxis;
  10.  
  11.  
  12. short RevMesh = DefRevMeshVal;
  13. short RevImageR, /* revolution index */
  14.       RevImageB; /* bezier index */
  15.  
  16. static int RotRange = DefRotRange;
  17. static int RotStart = DefRotStart;
  18. static int SecAngle = DefTilt;
  19. static float SurfDist = DefSurfDist;
  20. static float ViewDist = DefViewDist;
  21. static bool Perspective = DefPersp;
  22.  
  23. void SetPerspective(  value)
  24.     int value;
  25. {
  26.     Perspective = value;
  27. }
  28.  
  29.  
  30.  
  31. void SetRevAxis( value)
  32.  
  33. {
  34.     RevAxis = (value)? RevY : RevX;
  35. }
  36.  
  37.  
  38. void SetRotStart( value )
  39.     int value;
  40. {
  41.     RotStart = value;
  42. }
  43.  
  44. void SetRotRange(  value )
  45.     int value;
  46. {
  47.     RotRange = value;
  48. }
  49.  
  50. void SetSecAng( value )
  51.     int value;
  52. {
  53.     SecAngle = value;
  54. }
  55.  
  56. void SetRevMesh( value )
  57.     int value;
  58. {
  59.     RevMesh = value;
  60. }
  61.  
  62.  
  63.  
  64. void SetSurfDist( value )
  65.     int value;
  66. {
  67.     SurfDist = (float )value;
  68. }
  69.  
  70.  
  71. void SetViewDist( value )
  72.     int value;
  73. {
  74.     ViewDist = (float )value;
  75. }
  76.  
  77.  
  78.  
  79. static
  80. float secsin, seccos; /* trig values of secondary angle */
  81.  
  82. static
  83. int sizeptlist = 0;
  84.  
  85. static
  86. PtGen *ptlist1 = 0,
  87.       *ptlist2 = 0;
  88.  
  89. static
  90. int NumEnts; /* number of angle slices */
  91.  
  92.  
  93. static
  94. bool PrepRev()
  95. {
  96.     NumEnts = RevMesh+1;
  97.  
  98.     /*
  99.      * allocate space 3d descriptions of a point revolved x degrees
  100.      */
  101.     if( NumEnts > sizeptlist ) {
  102.         if( ptlist1 ) free(ptlist1);
  103.         if( ptlist2 ) free(ptlist2);
  104.  
  105.         ptlist1 =(PtGen *) malloc( NumEnts * sizeof(PtGen)  );
  106.         ptlist2 =(PtGen *) malloc( NumEnts * sizeof(PtGen)  );
  107.         if( !ptlist1 || !ptlist2 ) {
  108.             OutErr("PrepRev:not enough memory");
  109.             return(true);
  110.         }
  111.     }
  112.  
  113.  
  114.     if( InitFastTrig( RotStart, RotRange, NumEnts)) return(true);
  115.     secsin = sin((float)SecAngle*PI/180);
  116.     seccos = cos((float)SecAngle*PI/180);
  117.     return (false);
  118. }
  119.  
  120.  
  121. static
  122. void CalcRing(ptlist, xpos, ypos)
  123. register PtGen *ptlist;
  124. float xpos, ypos;
  125. {
  126.     int angle;
  127.  
  128.     for( angle = 0; angle < NumEnts; angle++, ptlist++) {
  129.         float temp;
  130.         /*
  131.          * calculate 3d coordinate of point revolved
  132.          */
  133.         if( RevAxis == RevX) {
  134.             ptlist->d3.y = ypos * fcos(angle);
  135.             temp = ypos * fsin(angle);
  136.             ptlist->d3.x = xpos* seccos - temp *secsin;
  137.             ptlist->d3.z = xpos * secsin + temp * seccos;
  138.         }
  139.         else {
  140.             ptlist->d3.x = xpos * fcos(angle);
  141.             temp = xpos * fsin( angle);
  142.             ptlist->d3.y = ypos * seccos + temp * secsin;
  143.             ptlist->d3.z = secsin * ypos - temp * seccos;
  144.         }
  145.         ptlist->d3.z -= SurfDist;
  146.  
  147. /*        if( Perspective ) {
  148.             float PerspScale;
  149.  
  150.             PerspScale = fabs(ViewDist / ptlist->d3.z);
  151.             ptlist->d3.x *= PerspScale;
  152.             ptlist->d3.y *= PerspScale;
  153.         }
  154.  */
  155.         /*
  156.          * calculate the 2d screen coordinate equvalent
  157.          */
  158.       /*
  159.         ptlist->d2.x = (short) ptlist->d3.x;
  160.         ptlist->d2.y = (short) ptlist->d3.y;
  161.        */
  162.         ptlist->d2.x = (short) (ptlist->d3.x + 0.5);
  163.         ptlist->d2.y = (short) (ptlist->d3.y + 0.5);
  164.     }
  165. }
  166.  
  167.  
  168.  
  169.  
  170.  
  171.  
  172. /*
  173.  * return true on failure
  174.  */
  175. bool Revolve(acceptfunc)
  176.     void (*acceptfunc)();
  177. {
  178.     float tparm, deltat;
  179.     int subseg;
  180.  
  181.     if( PrepRev() ) {
  182.         return(true);
  183.     }
  184.  
  185.     deltat = 1.0/BezMesh;
  186.     RevImageB = 0;
  187.     ResetActSeg();
  188.     do {
  189.         float xpos, ypos;
  190.  
  191.  
  192.         InitCalcBez();
  193.         xpos = StartPtX(GetCurSeg());
  194.         ypos = StartPtY(GetCurSeg());
  195.         CalcRing(ptlist1, xpos, ypos );
  196.         for( subseg = 1; subseg <= BezMesh; subseg++ ) {
  197.             register PtGen *ptlista, *ptlistb;
  198.             register int numpoly;
  199.  
  200.             tparm = subseg * deltat;
  201.             if( subseg & 1 ) {
  202.                 ptlista = ptlist2; ptlistb = ptlist1;
  203.             }
  204.             else {
  205.                 ptlista = ptlist1; ptlistb = ptlist2;
  206.             }
  207.  
  208.             CalcBezPt(tparm, &xpos, &ypos );
  209.             CalcRing( ptlista, xpos, ypos );
  210.             RevImageR = 0;
  211.             for( numpoly = NumEnts -1; numpoly--; ) {
  212.                 (* acceptfunc)(ptlistb, ptlista, ptlista+1, ptlistb+1);
  213.                 ptlista++;
  214.                 ptlistb++;
  215.                 RevImageR++;
  216.             }
  217.             RevImageB++;
  218.         }
  219.         NextSeg();
  220.  
  221.     } while( ActSeg );
  222.     return( false );
  223. }
  224.  
  225. /*
  226.  * write a ring of points
  227.  */
  228. static void WriteRing(fileout, ptlist, numpnts)
  229. FILE *fileout;
  230. PtGen *ptlist;
  231. int numpnts;
  232. {
  233.     while( numpnts-- ) {
  234.         fprintf(fileout, "%f %f %f \n", ptlist->d3.x,
  235.             ptlist->d3.y, ptlist->d3.z );
  236.             ptlist++;
  237.     }
  238. }
  239.  
  240. /*
  241.  * write the list of vertices to file pointer
  242.  * this function performs a similar function to revolve
  243.  */
  244. static void WriteRevolve(fileout)
  245.     FILE *fileout;
  246. {
  247.     float tparm, deltat;
  248.     float OldSurfDist;
  249.     int subseg;
  250.     float xpos, ypos;
  251.  
  252.  
  253.     OldSurfDist = SurfDist;
  254.     SurfDist = 0;
  255.     deltat = 1.0/BezMesh;
  256.     RevImageB = 0;
  257.     ResetActSeg();
  258.     /*
  259.      * write out the starting ring
  260.      */
  261.     InitCalcBez();
  262.     xpos = StartPtX(GetCurSeg());
  263.     ypos = StartPtY(GetCurSeg());
  264.     CalcRing(ptlist1, xpos, ypos );
  265.     WriteRing(fileout, ptlist1, NumEnts);
  266.     /*
  267.      * loop to write out all the other rings
  268.      */
  269.     do {
  270.  
  271.         InitCalcBez();
  272.         for( subseg = 1; subseg <= BezMesh; subseg++ ) {
  273.             tparm = subseg * deltat;
  274.             CalcBezPt(tparm, &xpos, &ypos );
  275.             CalcRing( ptlist1, xpos, ypos );
  276.             WriteRing(fileout, ptlist1, NumEnts);
  277.             RevImageB++;
  278.         }
  279.         NextSeg();
  280.  
  281.     } while( ActSeg );
  282.     SurfDist = OldSurfDist;
  283.  
  284.     return;
  285. }
  286.  
  287. /*
  288.  * this function writes a list of vertices to "filename"
  289.  */
  290. void WriteData(filename)
  291.     char *filename;
  292. {
  293.         FILE *fileout;
  294.  
  295.         if(( GetNumSegs() < 1) || PrepRev()){
  296.                 return;
  297.         }
  298.  
  299.         fileout = fopen(filename,"w");
  300.         if(!fileout) {
  301.             OutErr("could not open data file");
  302.             return;
  303.         }
  304.  
  305.  
  306.         fprintf(fileout, "%d   * number of Rings\n", BezRings());
  307.         fprintf(fileout, "%d   * Rev mesh\n", RevMesh);
  308.         fprintf(fileout, "%d   * Rotation range\n", RotRange);
  309.         WriteRevolve(fileout);
  310.         fprintf(fileout, "end\n");
  311.         fclose(fileout);
  312. }
  313.  
  314.  
  315.  
  316.